Explain the following object oriented concepts: (a) Objects, (b) Classes, (c) Encapsulation, (d) Inheritance, (e) Polymorphism, (f) Message passing.

Object-Oriented Concepts

Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects" which can contain data and code. It provides a structured approach to software development by organizing code into reusable, self-contained units. The following are the core concepts of object-oriented programming:

(a) Objects

Objects are the basic runtime entities in an object-oriented system. An object represents a real-world entity that has:

State: The data or attributes that describe the object
Behavior: The actions or methods that the object can perform
Identity: A unique identifier that distinguishes it from other objects

Objects are instances of classes and serve as the building blocks of object-oriented applications. They encapsulate both data and the operations that manipulate that data.

Example:

// A car object with state (color, make, model, year)
Car myCar = new Car("Red", "Toyota", "Corolla", 2020);

// Behavior - invoking methods on the object
myCar.startEngine();
myCar.accelerate(50);

In this example, myCar is an object of the Car class with specific attributes and behaviors.

(b) Classes

A class is a blueprint or template that defines the structure and behavior that objects of that type will have. It serves as a prototype for creating objects and specifies:

Attributes: Variables that store data
Methods: Functions that define behavior
Constructors: Special methods for initializing objects
Access controls: Visibility modifiers for attributes and methods

Classes encapsulate all the features of a particular set of objects, allowing developers to create consistent and predictable objects.

Example:

public class Car {
    // Attributes (state)
    private String color;
    private String make;
    private String model;
    private int year;
    private boolean engineRunning;
    
    // Constructor
    public Car(String color, String make, String model, int year) {
        this.color = color;
        this.make = make;
        this.model = model;
        this.year = year;
        this.engineRunning = false;
    }
    
    // Methods (behavior)
    public void startEngine() {
        engineRunning = true;
        System.out.println("Engine started");
    }
    
    public void stopEngine() {
        engineRunning = false;
        System.out.println("Engine stopped");
    }
    
    public void accelerate(int speed) {
        if (engineRunning) {
            System.out.println("Accelerating to " + speed + " mph");
        } else {
            System.out.println("Cannot accelerate - engine is not running");
        }
    }
}

(c) Encapsulation

Encapsulation is the bundling of data and methods that operate on that data within a single unit (class) and restricting access to some of the object's components. It serves two key purposes:

Information Hiding: Hiding internal state and implementation details
Interface Provision: Exposing a controlled interface for interacting with the object

Through encapsulation, a class can control how its data is accessed and modified, ensuring data integrity and reducing system complexity.

Key Features:

Access Modifiers: Using private, protected, and public to control access
Getter/Setter Methods: Providing controlled access to private attributes
Validation: Ensuring data meets specific criteria before modification

Example:

public class BankAccount {
    // Private attributes - hidden from outside
    private String accountNumber;
    private double balance;
    
    // Public constructor
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        } else {
            throw new IllegalArgumentException("Initial balance cannot be negative");
        }
    }
    
    // Getter method - controlled access to read data
    public double getBalance() {
        return balance;
    }
    
    // Methods that modify the state with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            throw new IllegalArgumentException("Deposit amount must be positive");
        }
    }
    
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
}

In this example, the balance attribute is private and can only be modified through controlled methods (deposit and withdraw) that include validation.

(d) Inheritance

Inheritance is a mechanism that allows a class (child/derived class) to inherit attributes and methods from another class (parent/base class). It enables:

Code Reuse: Avoiding duplication by inheriting common functionality
Hierarchical Classification: Organizing classes in a parent-child relationship
Specialization: Creating more specific versions of general classes

Inheritance represents an "is-a" relationship between classes, where the child class is a specialized version of the parent class.

Types of Inheritance:

Single Inheritance: A class inherits from one parent class
Multiple Inheritance: A class inherits from multiple parent classes (not supported in all languages)
Multilevel Inheritance: A class inherits from a child class (creating a hierarchy)
Hierarchical Inheritance: Multiple classes inherit from a single parent class

Example:

// Parent/Base class
public class Vehicle {
    protected String make;
    protected String model;
    protected int year;
    
    public Vehicle(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }
    
    public void startEngine() {
        System.out.println("Engine started");
    }
    
    public void stopEngine() {
        System.out.println("Engine stopped");
    }
}

// Child/Derived class inheriting from Vehicle
public class Car extends Vehicle {
    private int numberOfDoors;
    private boolean convertible;
    
    public Car(String make, String model, int year, int numberOfDoors, boolean convertible) {
        // Call parent constructor
        super(make, model, year);
        this.numberOfDoors = numberOfDoors;
        this.convertible = convertible;
    }
    
    // Additional method specific to Car
    public void honkHorn() {
        System.out.println("Honk! Honk!");
    }
    
    // Override parent method
    @Override
    public void startEngine() {
        System.out.println("Car engine started with key");
    }
}

In this example, Car inherits common attributes and methods from Vehicle while adding its own specific features.

(e) Polymorphism

Polymorphism means "many forms" and refers to the ability of different objects to respond to the same method call in ways specific to their individual types. There are two main types of polymorphism:

Compile-time Polymorphism (Method Overloading): Multiple methods with the same name but different parameters
Runtime Polymorphism (Method Overriding): Subclass provides a specific implementation of a method defined in its parent class

Polymorphism allows:

Single Interface, Multiple Implementations: Using one interface to represent different underlying forms
Dynamic Method Dispatch: Determining which method to call at runtime based on the object type
Flexible Code Design: Writing code that works with objects of various types

Example:

// Parent class
public class Shape {
    public double calculateArea() {
        return 0; // Default implementation
    }
    
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

// Child classes with overridden methods
public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
    
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

// Polymorphic usage
public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle(5);
        Shape shape2 = new Rectangle(4, 6);
        
        // Same method call, different behaviors
        System.out.println("Circle area: " + shape1.calculateArea());
        System.out.println("Rectangle area: " + shape2.calculateArea());
        
        shape1.draw();  // Outputs: Drawing a circle
        shape2.draw();  // Outputs: Drawing a rectangle
    }
}

In this example, shape1 and shape2 are both declared as Shape references, but they behave differently when the same methods are called, demonstrating polymorphism.

(f) Message Passing

Message passing is the process by which an object sends information to another object or requests the other object to invoke a method. It is the way objects interact with each other and is a fundamental concept in object-oriented programming.

Key aspects of message passing:

Method Invocation: Calling a method on an object
Parameter Passing: Sending data to the receiving object
Return Values: Getting results back from the receiving object
Asynchronous Communication: In some systems, messages can be queued and processed later

Message passing enables loose coupling between objects, as they interact through well-defined interfaces rather than direct access to each other's internal state.

Example:

public class Customer {
    private String name;
    private String email;
    
    public Customer(String name, String email) {
        this.name = name;
        this.email = email;
    }
    
    // Method to receive and process a message
    public void receiveNotification(String message) {
        System.out.println("Notification sent to " + name + ": " + message);
    }
}

public class OrderSystem {
    private List<Customer> customers;
    
    public OrderSystem() {
        customers = new ArrayList<>();
    }
    
    public void addCustomer(Customer customer) {
        customers.add(customer);
    }
    
    public void processOrder(Order order) {
        // Process the order
        System.out.println("Processing order: " + order.getId());
        
        // Send notification to customer (message passing)
        Customer customer = order.getCustomer();
        customer.receiveNotification("Your order " + order.getId() + " has been processed.");
    }
}

// Usage example
public class Main {
    public static void main(String[] args) {
        OrderSystem system = new OrderSystem();
        
        Customer customer = new Customer("John Doe", "john@example.com");
        system.addCustomer(customer);
        
        Order order = new Order("ORD-12345", customer);
        
        // Message passing occurs inside processOrder
        system.processOrder(order);
    }
}

In this example, when the OrderSystem processes an order, it passes a message to the Customer object by invoking its receiveNotification method with a string parameter.

These six concepts—objects, classes, encapsulation, inheritance, polymorphism, and message passing—form the foundation of object-oriented programming and provide a powerful framework for designing and implementing complex software systems.

Object-Oriented Concepts​

(a) Objects​

Example:​

(b) Classes​

Example:​

(c) Encapsulation​

Key Features:​

Example:​

(d) Inheritance​

Types of Inheritance:​

Example:​

(e) Polymorphism​

Example:​

(f) Message Passing​

Example:​

Object-Oriented Concepts

(a) Objects

Example:

(b) Classes

Example:

(c) Encapsulation

Key Features:

Example:

(d) Inheritance

Types of Inheritance:

Example:

(e) Polymorphism

Example:

(f) Message Passing

Example: